/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package br.projecao.time.controle;

import br.projecao.time.ProjetoUsuarioAtividade;
import br.projecao.time.ProjetoUsuarioAtividadePK;
import br.projecao.time.controle.exceptions.IllegalOrphanException;
import br.projecao.time.controle.exceptions.NonexistentEntityException;
import br.projecao.time.controle.exceptions.PreexistingEntityException;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import br.projecao.time.ProjetoUsuario;
import br.projecao.time.Atividade;
import br.projecao.time.HoraTrabalhada;
import java.util.ArrayList;
import java.util.Collection;

/**
 *
 * @author edson.sousa
 */
public class ProjetoUsuarioAtividadeJpaController {

    public ProjetoUsuarioAtividadeJpaController() {
        emf = Persistence.createEntityManagerFactory("timePU");
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(ProjetoUsuarioAtividade projetoUsuarioAtividade) throws PreexistingEntityException, Exception {
        if (projetoUsuarioAtividade.getProjetoUsuarioAtividadePK() == null) {
            projetoUsuarioAtividade.setProjetoUsuarioAtividadePK(new ProjetoUsuarioAtividadePK());
        }
        if (projetoUsuarioAtividade.getHoraTrabalhadaCollection() == null) {
            projetoUsuarioAtividade.setHoraTrabalhadaCollection(new ArrayList<HoraTrabalhada>());
        }
        projetoUsuarioAtividade.getProjetoUsuarioAtividadePK().setAtividade(projetoUsuarioAtividade.getAtividade1().getIdAtividade());
        projetoUsuarioAtividade.getProjetoUsuarioAtividadePK().setProjeto(projetoUsuarioAtividade.getProjetoUsuario().getProjetoUsuarioPK().getProjeto());
        projetoUsuarioAtividade.getProjetoUsuarioAtividadePK().setUsuario(projetoUsuarioAtividade.getProjetoUsuario().getProjetoUsuarioPK().getUsuario());
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            ProjetoUsuario projetoUsuario = projetoUsuarioAtividade.getProjetoUsuario();
            if (projetoUsuario != null) {
                projetoUsuario = em.getReference(projetoUsuario.getClass(), projetoUsuario.getProjetoUsuarioPK());
                projetoUsuarioAtividade.setProjetoUsuario(projetoUsuario);
            }
            Atividade atividade1 = projetoUsuarioAtividade.getAtividade1();
            if (atividade1 != null) {
                atividade1 = em.getReference(atividade1.getClass(), atividade1.getIdAtividade());
                projetoUsuarioAtividade.setAtividade1(atividade1);
            }
            Collection<HoraTrabalhada> attachedHoraTrabalhadaCollection = new ArrayList<HoraTrabalhada>();
            for (HoraTrabalhada horaTrabalhadaCollectionHoraTrabalhadaToAttach : projetoUsuarioAtividade.getHoraTrabalhadaCollection()) {
                horaTrabalhadaCollectionHoraTrabalhadaToAttach = em.getReference(horaTrabalhadaCollectionHoraTrabalhadaToAttach.getClass(), horaTrabalhadaCollectionHoraTrabalhadaToAttach.getHoraTrabalhadaPK());
                attachedHoraTrabalhadaCollection.add(horaTrabalhadaCollectionHoraTrabalhadaToAttach);
            }
            projetoUsuarioAtividade.setHoraTrabalhadaCollection(attachedHoraTrabalhadaCollection);
            em.persist(projetoUsuarioAtividade);
            if (projetoUsuario != null) {
                projetoUsuario.getProjetoUsuarioAtividadeCollection().add(projetoUsuarioAtividade);
                projetoUsuario = em.merge(projetoUsuario);
            }
            if (atividade1 != null) {
                atividade1.getProjetoUsuarioAtividadeCollection().add(projetoUsuarioAtividade);
                atividade1 = em.merge(atividade1);
            }
            for (HoraTrabalhada horaTrabalhadaCollectionHoraTrabalhada : projetoUsuarioAtividade.getHoraTrabalhadaCollection()) {
                ProjetoUsuarioAtividade oldProjetoUsuarioAtividadeOfHoraTrabalhadaCollectionHoraTrabalhada = horaTrabalhadaCollectionHoraTrabalhada.getProjetoUsuarioAtividade();
                horaTrabalhadaCollectionHoraTrabalhada.setProjetoUsuarioAtividade(projetoUsuarioAtividade);
                horaTrabalhadaCollectionHoraTrabalhada = em.merge(horaTrabalhadaCollectionHoraTrabalhada);
                if (oldProjetoUsuarioAtividadeOfHoraTrabalhadaCollectionHoraTrabalhada != null) {
                    oldProjetoUsuarioAtividadeOfHoraTrabalhadaCollectionHoraTrabalhada.getHoraTrabalhadaCollection().remove(horaTrabalhadaCollectionHoraTrabalhada);
                    oldProjetoUsuarioAtividadeOfHoraTrabalhadaCollectionHoraTrabalhada = em.merge(oldProjetoUsuarioAtividadeOfHoraTrabalhadaCollectionHoraTrabalhada);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findProjetoUsuarioAtividade(projetoUsuarioAtividade.getProjetoUsuarioAtividadePK()) != null) {
                throw new PreexistingEntityException("ProjetoUsuarioAtividade " + projetoUsuarioAtividade + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(ProjetoUsuarioAtividade projetoUsuarioAtividade) throws IllegalOrphanException, NonexistentEntityException, Exception {
        projetoUsuarioAtividade.getProjetoUsuarioAtividadePK().setAtividade(projetoUsuarioAtividade.getAtividade1().getIdAtividade());
        projetoUsuarioAtividade.getProjetoUsuarioAtividadePK().setProjeto(projetoUsuarioAtividade.getProjetoUsuario().getProjetoUsuarioPK().getProjeto());
        projetoUsuarioAtividade.getProjetoUsuarioAtividadePK().setUsuario(projetoUsuarioAtividade.getProjetoUsuario().getProjetoUsuarioPK().getUsuario());
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            ProjetoUsuarioAtividade persistentProjetoUsuarioAtividade = em.find(ProjetoUsuarioAtividade.class, projetoUsuarioAtividade.getProjetoUsuarioAtividadePK());
            ProjetoUsuario projetoUsuarioOld = persistentProjetoUsuarioAtividade.getProjetoUsuario();
            ProjetoUsuario projetoUsuarioNew = projetoUsuarioAtividade.getProjetoUsuario();
            Atividade atividade1Old = persistentProjetoUsuarioAtividade.getAtividade1();
            Atividade atividade1New = projetoUsuarioAtividade.getAtividade1();
            Collection<HoraTrabalhada> horaTrabalhadaCollectionOld = persistentProjetoUsuarioAtividade.getHoraTrabalhadaCollection();
            Collection<HoraTrabalhada> horaTrabalhadaCollectionNew = projetoUsuarioAtividade.getHoraTrabalhadaCollection();
            List<String> illegalOrphanMessages = null;
            for (HoraTrabalhada horaTrabalhadaCollectionOldHoraTrabalhada : horaTrabalhadaCollectionOld) {
                if (!horaTrabalhadaCollectionNew.contains(horaTrabalhadaCollectionOldHoraTrabalhada)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain HoraTrabalhada " + horaTrabalhadaCollectionOldHoraTrabalhada + " since its projetoUsuarioAtividade field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (projetoUsuarioNew != null) {
                projetoUsuarioNew = em.getReference(projetoUsuarioNew.getClass(), projetoUsuarioNew.getProjetoUsuarioPK());
                projetoUsuarioAtividade.setProjetoUsuario(projetoUsuarioNew);
            }
            if (atividade1New != null) {
                atividade1New = em.getReference(atividade1New.getClass(), atividade1New.getIdAtividade());
                projetoUsuarioAtividade.setAtividade1(atividade1New);
            }
            Collection<HoraTrabalhada> attachedHoraTrabalhadaCollectionNew = new ArrayList<HoraTrabalhada>();
            for (HoraTrabalhada horaTrabalhadaCollectionNewHoraTrabalhadaToAttach : horaTrabalhadaCollectionNew) {
                horaTrabalhadaCollectionNewHoraTrabalhadaToAttach = em.getReference(horaTrabalhadaCollectionNewHoraTrabalhadaToAttach.getClass(), horaTrabalhadaCollectionNewHoraTrabalhadaToAttach.getHoraTrabalhadaPK());
                attachedHoraTrabalhadaCollectionNew.add(horaTrabalhadaCollectionNewHoraTrabalhadaToAttach);
            }
            horaTrabalhadaCollectionNew = attachedHoraTrabalhadaCollectionNew;
            projetoUsuarioAtividade.setHoraTrabalhadaCollection(horaTrabalhadaCollectionNew);
            projetoUsuarioAtividade = em.merge(projetoUsuarioAtividade);
            if (projetoUsuarioOld != null && !projetoUsuarioOld.equals(projetoUsuarioNew)) {
                projetoUsuarioOld.getProjetoUsuarioAtividadeCollection().remove(projetoUsuarioAtividade);
                projetoUsuarioOld = em.merge(projetoUsuarioOld);
            }
            if (projetoUsuarioNew != null && !projetoUsuarioNew.equals(projetoUsuarioOld)) {
                projetoUsuarioNew.getProjetoUsuarioAtividadeCollection().add(projetoUsuarioAtividade);
                projetoUsuarioNew = em.merge(projetoUsuarioNew);
            }
            if (atividade1Old != null && !atividade1Old.equals(atividade1New)) {
                atividade1Old.getProjetoUsuarioAtividadeCollection().remove(projetoUsuarioAtividade);
                atividade1Old = em.merge(atividade1Old);
            }
            if (atividade1New != null && !atividade1New.equals(atividade1Old)) {
                atividade1New.getProjetoUsuarioAtividadeCollection().add(projetoUsuarioAtividade);
                atividade1New = em.merge(atividade1New);
            }
            for (HoraTrabalhada horaTrabalhadaCollectionNewHoraTrabalhada : horaTrabalhadaCollectionNew) {
                if (!horaTrabalhadaCollectionOld.contains(horaTrabalhadaCollectionNewHoraTrabalhada)) {
                    ProjetoUsuarioAtividade oldProjetoUsuarioAtividadeOfHoraTrabalhadaCollectionNewHoraTrabalhada = horaTrabalhadaCollectionNewHoraTrabalhada.getProjetoUsuarioAtividade();
                    horaTrabalhadaCollectionNewHoraTrabalhada.setProjetoUsuarioAtividade(projetoUsuarioAtividade);
                    horaTrabalhadaCollectionNewHoraTrabalhada = em.merge(horaTrabalhadaCollectionNewHoraTrabalhada);
                    if (oldProjetoUsuarioAtividadeOfHoraTrabalhadaCollectionNewHoraTrabalhada != null && !oldProjetoUsuarioAtividadeOfHoraTrabalhadaCollectionNewHoraTrabalhada.equals(projetoUsuarioAtividade)) {
                        oldProjetoUsuarioAtividadeOfHoraTrabalhadaCollectionNewHoraTrabalhada.getHoraTrabalhadaCollection().remove(horaTrabalhadaCollectionNewHoraTrabalhada);
                        oldProjetoUsuarioAtividadeOfHoraTrabalhadaCollectionNewHoraTrabalhada = em.merge(oldProjetoUsuarioAtividadeOfHoraTrabalhadaCollectionNewHoraTrabalhada);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                ProjetoUsuarioAtividadePK id = projetoUsuarioAtividade.getProjetoUsuarioAtividadePK();
                if (findProjetoUsuarioAtividade(id) == null) {
                    throw new NonexistentEntityException("The projetoUsuarioAtividade with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(ProjetoUsuarioAtividadePK id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            ProjetoUsuarioAtividade projetoUsuarioAtividade;
            try {
                projetoUsuarioAtividade = em.getReference(ProjetoUsuarioAtividade.class, id);
                projetoUsuarioAtividade.getProjetoUsuarioAtividadePK();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The projetoUsuarioAtividade with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Collection<HoraTrabalhada> horaTrabalhadaCollectionOrphanCheck = projetoUsuarioAtividade.getHoraTrabalhadaCollection();
            for (HoraTrabalhada horaTrabalhadaCollectionOrphanCheckHoraTrabalhada : horaTrabalhadaCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This ProjetoUsuarioAtividade (" + projetoUsuarioAtividade + ") cannot be destroyed since the HoraTrabalhada " + horaTrabalhadaCollectionOrphanCheckHoraTrabalhada + " in its horaTrabalhadaCollection field has a non-nullable projetoUsuarioAtividade field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            ProjetoUsuario projetoUsuario = projetoUsuarioAtividade.getProjetoUsuario();
            if (projetoUsuario != null) {
                projetoUsuario.getProjetoUsuarioAtividadeCollection().remove(projetoUsuarioAtividade);
                projetoUsuario = em.merge(projetoUsuario);
            }
            Atividade atividade1 = projetoUsuarioAtividade.getAtividade1();
            if (atividade1 != null) {
                atividade1.getProjetoUsuarioAtividadeCollection().remove(projetoUsuarioAtividade);
                atividade1 = em.merge(atividade1);
            }
            em.remove(projetoUsuarioAtividade);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<ProjetoUsuarioAtividade> findProjetoUsuarioAtividadeEntities() {
        return findProjetoUsuarioAtividadeEntities(true, -1, -1);
    }

    public List<ProjetoUsuarioAtividade> findProjetoUsuarioAtividadeEntities(int maxResults, int firstResult) {
        return findProjetoUsuarioAtividadeEntities(false, maxResults, firstResult);
    }

    private List<ProjetoUsuarioAtividade> findProjetoUsuarioAtividadeEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(ProjetoUsuarioAtividade.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public ProjetoUsuarioAtividade findProjetoUsuarioAtividade(ProjetoUsuarioAtividadePK id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(ProjetoUsuarioAtividade.class, id);
        } finally {
            em.close();
        }
    }

    public int getProjetoUsuarioAtividadeCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<ProjetoUsuarioAtividade> rt = cq.from(ProjetoUsuarioAtividade.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
